package com.cx.anno;

import java.util.function.*;

/**
 * @author zhangshuai
 * @version V1.0
 * @Project Java2_26
 * @Package com.cx.anno
 * @Description:
 * @Date 2025/5/22 14:16
 */

public class InterfaceTest {
    public static void main(String[] args) {
        //函数式接口：只有一个抽象方法的函数
        //内置函数式接口：
        //Consumer<T>：接受一个参数，无返回值  消费型    BiConsumer<T, U>：接受两个参数，无返回值
        //Supplier<T>：无参数，返回一个结果   供给型     BiSupplier<T, U>：无参数，返回两个结果
        //Function<T, R>：接受一个参数，返回一个结果  函数型   BiFunction<T, U, R>：接受两个参数，返回一个结果
        //Predicate<T>：接受一个参数，返回一个布尔值  断言型   BiPredicate<T, U>：接受两个参数，返回一个布尔值

      //消费型
      new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s+"123456");
            }
        }.accept("Hello, Lambda!");
        //消费型的lambda表达式写法
        Consumer<String> consumer = (s) -> {
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            s += sum;
            System.out.println(s);
        };
        consumer.accept("Hello, Lambda!"+"lambda");

        //供给型
      Supplier supplier =  new Supplier<String>() {
            @Override
            public String get() {
                return "Hello, Lambda!+dsfsfds";
            }
        };
        System.out.println(supplier.get());

        //供给型的lambda表达式写法
        Supplier supplier1 = () -> {
            return "Hello, Lambda!";
        };
        System.out.println(supplier1.get()+"lambda");

        //函数型
        Function<String, Integer> function =  new Function<String,Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };
        System.out.println(function.apply("Hello, Lambda!"));
        Function<String, Integer> function1 = (s) -> {
            return s.length();
        };
        System.out.println(function1.apply("Hello, Lambda!"+"lambda"));

        //断言型
        Predicate predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 10;
            }
        };

        System.out.println(predicate.test("Hello, Lambda!"));

        Predicate<String> predicate1 = (s) -> {
            return s.length() > 20;
        };
        System.out.println(predicate1.test("Hello, Lambda!"+"lambda"));

        new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s + " " + integer);
            }
        }.accept("Hello, Lambda!", 123);




    }







}